import { defineStore } from 'pinia'
import { login, register, getUserInfo, updateUserInfo, updatePassword, getCommentReplies, getMyComments, logout } from '@/api/auth'
import router from '@/router'
import { ElMessage } from 'element-plus'

// 定义Token的生存期为7天
const TOKEN_EXPIRY = 7 * 24 * 60 * 60 * 1000

// 后端token生效需要的延迟时间(毫秒)
const TOKEN_DELAY = 1000

// 最大重试次数
const MAX_RETRY_COUNT = 3

// 重试间隔(毫秒)
const RETRY_INTERVAL = 1000

export const useUserStore = defineStore('user', {
  state: () => {
    // 检查本地存储中的Token是否有效（未过期）
    const tokenData = JSON.parse(localStorage.getItem('tokenData') || '{"token":"","timestamp":0}')
    const isTokenValid = tokenData.timestamp && (Date.now() - tokenData.timestamp < TOKEN_EXPIRY)
    
    return {
      token: isTokenValid ? tokenData.token : '',
      userInfo: isTokenValid ? JSON.parse(localStorage.getItem('userInfo') || 'null') : null,
      avatar: '', // 空字符串，将使用组件内置的默认头像
      nickname: '未登录',
      fetchingUserInfo: false, // 标识是否正在获取用户信息
      loginSuccess: false,     // 标记登录是否成功
      
      // 我的评论和回复数据
      myComments: [],
      commentReplies: [],
      commentsLoading: false,
      repliesLoading: false,
      
      // 分页数据
      commentsPagination: {
        total: 0,
        pageNum: 1,
        pageSize: 10
      },
      repliesPagination: {
        total: 0,
        pageNum: 1,
        pageSize: 10
      }
    }
  },

  getters: {
    isLoggedIn: (state) => !!state.token,
    // 获取用户信息的便捷方法
    getUserProfile: (state) => state.userInfo || {}
  },

  actions: {
    // 获取我的评论列表
    async fetchMyComments(params = {}) {
      // 如果没有token，返回空数据但不跳转
      if (!this.token) {
        console.warn('获取评论失败: 未登录状态')
        this.myComments = []
        ElMessage.error('获取评论失败: 未登录状态')
        return false
      }
      
      try {
        this.commentsLoading = true
        console.log('正在获取我的评论...')
        
        // 更新分页参数
        const pageNum = params.pageNum || params.page || this.commentsPagination.pageNum
        const pageSize = params.pageSize || this.commentsPagination.pageSize
        
        const queryParams = {
          ...params,
          pageNum,
          pageSize
        }
        
        const res = await getMyComments(queryParams)
        console.log('获取评论结果:', res)
        
        if (res.code === 0 || res.code === 200) {
          // 适配后端真实数据结构
          const data = res.data || {}
          const records = data.records || []
          
          console.log('评论数据:', records)
          
          // 转换为前端展示需要的结构
          this.myComments = records.map(item => ({
            id: item.commentId || '',
            content: item.commentContent || '',
            postTitle: item.replyToName || '未知帖子', // 回复的帖子标题
            createTime: item.commentTime || '',
            author: {
              id: this.userInfo?.userId,
              name: item.commentUser || this.userInfo?.nickname || '匿名用户',
              avatar: item.commentAvatar || this.userInfo?.avatar || ''
            }
          }))
          
          // 更新分页信息
          this.commentsPagination = {
            total: data.total || 0,
            pageNum: pageNum,
            pageSize: pageSize
          }
          
          return true
        } else if (res.code === 401) {
          // 处理权限问题，但不跳转
          console.warn('获取评论失败: 授权失效，但不跳转')
          this.myComments = []
          ElMessage.error(res.message || '获取评论失败，请重新登录')
          return false
        } else {
          // 处理其他错误
          console.warn('获取评论失败:', res)
          this.myComments = []
          ElMessage.error(res.message || '获取评论失败')
          return false
        }
      } catch (error) {
        console.error('获取我的评论失败，详细错误:', error)
        console.error('错误类型:', error.name)
        console.error('错误消息:', error.message)
        console.error('错误堆栈:', error.stack)
        console.error('请求信息:', error.config)
        
        this.myComments = []
        ElMessage.error(`获取评论失败: ${error.message}`)
        return false
      } finally {
        this.commentsLoading = false
      }
    },
    
    // 获取评论回复列表
    async fetchCommentReplies(params = {}) {
      // 如果没有token，返回空数据但不跳转
      if (!this.token) {
        console.warn('获取评论回复失败: 未登录状态')
        this.commentReplies = []
        ElMessage.error('获取评论回复失败: 未登录状态')
        return false
      }
      
      try {
        this.repliesLoading = true
        console.log('正在获取评论回复...')
        
        // 更新分页参数
        const pageNum = params.pageNum || params.page || this.repliesPagination.pageNum
        const pageSize = params.pageSize || this.repliesPagination.pageSize
        
        const queryParams = {
          ...params,
          pageNum,
          pageSize
        }
        
        const res = await getCommentReplies(queryParams)
        console.log('获取评论回复结果:', res)
        
        if (res.code === 0 || res.code === 200) {
          // 适配后端真实数据结构
          const data = res.data || {}
          const records = data.records || []
          
          console.log('评论回复数据:', records)
          
          // 转换为前端展示需要的结构
          this.commentReplies = records.map(item => ({
            id: item.commentId || '',
            content: item.commentContent || '',
            createTime: item.commentTime || '',
            author: {
              id: item.commentId, // 回复者的ID
              nickname: item.commentUser || '匿名用户',
              avatar: item.commentAvatar || '',
              name: item.commentUser || '匿名用户'
            },
            replyTo: {
              id: item.topId || 0,
              name: item.replyToName || '原评论'
            }
          }))
          
          // 更新分页信息
          this.repliesPagination = {
            total: data.total || 0,
            pageNum: pageNum,
            pageSize: pageSize
          }
          
          return true
        } else if (res.code === 401) {
          // 处理权限问题，但不跳转
          console.warn('获取评论回复失败: 授权失效，但不跳转')
          this.commentReplies = []
          ElMessage.error(res.message || '获取评论回复失败，请重新登录')
          return false
        } else {
          // 处理其他错误
          console.warn('获取评论回复失败:', res)
          this.commentReplies = []
          ElMessage.error(res.message || '获取评论回复失败')
          return false
        }
      } catch (error) {
        console.error('获取评论回复失败，详细错误:', error)
        console.error('错误类型:', error.name)
        console.error('错误消息:', error.message)
        console.error('错误堆栈:', error.stack)
        console.error('请求信息:', error.config)
        
        this.commentReplies = []
        ElMessage.error(`获取评论回复失败: ${error.message}`)
        return false
      } finally {
        this.repliesLoading = false
      }
    },

    // 获取用户信息 - 静默获取模式，不会影响登录流程
    async fetchUserInfo() {
      // 如果没有token或者已经在获取中，则跳过
      if (!this.token || this.fetchingUserInfo) {
        return false
      }
      
      try {
        // 标记为正在获取中，防止重复调用
        this.fetchingUserInfo = true
        
        // 使用静默模式调用API，不显示错误
        const res = await getUserInfo({ silent: true })
        
        // 401状态处理 - 只在用户主动请求用户信息时才跳转
        if (res.code === 401) {
          console.warn('获取用户信息失败: 授权失效')
          // 只清理数据，不跳转
          this.token = ''
          this.userInfo = null
          this.nickname = '未登录'
          this.avatar = ''
          this.loginSuccess = false
          return false
        }
        
        if (res.code === 200 || res.code === 0) {
          const userData = res.data || {}
          
          // 构建标准的用户信息对象
          const userInfo = {
            userId: userData.userId || 0,
            username: userData.username || '',
            nickname: userData.nickname || userData.username || '',
            avatar: userData.avatar || '',
            gender: userData.gender || 0,
            age: userData.age || '',
            school: userData.school || '',
            status: userData.status || 0,
            email: userData.email || '',
            phone: userData.phone || ''
          }
          
          this.setUserInfo(userInfo)
          return true
        }
        return false
      } catch (error) {
        // 完全静默处理错误，不打印任何日志
        console.warn('获取用户信息出错:', error)
        return false
      } finally {
        // 无论成功失败，都重置获取状态
        this.fetchingUserInfo = false
      }
    },

    // 登录
    async login(credentials) {
      try {
        // 调用登录接口
        const res = await login(credentials)
        
        if (res.code === 200 || res.code === 0) {
          // 提取数据 - 根据后端真实返回的数据结构调整
          const userData = res.data || {}
          const token = userData.token || ''
          
          if (!token) {
            console.error('登录成功但未返回token')
            return false
          }
          
          // 设置token
          this.setToken(token)
          
          // 标记登录成功
          this.loginSuccess = true
          
          // 构建用户信息对象
          const userInfo = {
            userId: userData.userId || 0,
            username: userData.username || '',
            nickname: userData.nickname || userData.username || '',
            avatar: userData.avatar || '',
            gender: userData.gender || 0,
            age: userData.age || '',
            school: userData.school || '',
            status: userData.status || 0,
            email: userData.email || '',
            phone: userData.phone || ''
          }
          
          console.log('登录成功，用户数据:', userData)
          
          // 设置用户信息
          this.setUserInfo(userInfo)
          return true
        }
        return false
      } catch (error) {
        console.error('登录失败:', error)
        return false
      }
    },
    
    // 重试获取用户信息
    retryFetchUserInfo(remainingRetries = MAX_RETRY_COUNT, delay = TOKEN_DELAY) {
      setTimeout(async () => {
        try {
          // 尝试获取用户信息
          const result = await this.fetchUserInfo()
          
          // 如果失败且还有重试次数，则继续重试
          if (!result && remainingRetries > 1) {
            console.log(`获取用户信息重试中 (剩余${remainingRetries - 1}次)...`)
            this.retryFetchUserInfo(remainingRetries - 1, RETRY_INTERVAL)
          }
        } catch (err) {
          // 如果还有重试次数，则继续重试
          if (remainingRetries > 1) {
            console.log(`获取用户信息重试中 (剩余${remainingRetries - 1}次)...`)
            this.retryFetchUserInfo(remainingRetries - 1, RETRY_INTERVAL)
          }
        }
      }, delay)
    },

    // 注册
    async register(userData) {
      try {
        // 调用注册接口
        const res = await register({
          username: userData.username,
          password: userData.password
        })
        return res.code === 200 || res.code === 0
      } catch (error) {
        console.error('注册失败:', error)
        return false
      }
    },

    // 设置token
    setToken(token) {
      // 确保token是纯字符串
      if (token && typeof token === 'string') {
        this.token = token
        
        // 存储token及其时间戳
        localStorage.setItem('tokenData', JSON.stringify({
          token,
          timestamp: Date.now()
        }))
        
        // 同时保存原始格式的token，兼容其他组件
        localStorage.setItem('token', token)
        
        console.log('Token已设置并存储')
      } else {
        console.error('无效的token格式:', token)
      }
    },

    // 设置用户信息
    setUserInfo(userInfo) {
      if (!userInfo) return
      
      this.userInfo = userInfo
      this.nickname = userInfo.nickname || userInfo.username || '未登录'
      // 只有当头像有值时才设置
      if (userInfo.avatar) {
        this.avatar = userInfo.avatar
      }
      // 持久化存储用户信息
      localStorage.setItem('userInfo', JSON.stringify(userInfo))
    },

    // 退出登录
    async logout() {
      try {
        await logout()
      } catch (error) {
        console.error('退出登录时出错:', error)
      } finally {
        this.clearUserData()
        // 返回登录页
        router.push('/auth/login')
      }
    },
    
    // 清除用户数据
    clearUserData() {
      // 清除所有pending请求
      if (this.currentRequest) {
        this.currentRequest.cancel('用户主动登出')
      }
      
      // 清除浏览器缓存
      localStorage.removeItem('tokenData')
      localStorage.removeItem('token')
      localStorage.removeItem('userInfo')
      sessionStorage.clear()
      
      // 重置所有状态
      this.$reset()
      
      // 强制刷新页面清除内存残留
      window.location.reload()
    },

    // 更新用户信息
    async updateUserInfo(userInfo) {
      try {
        const res = await updateUserInfo(userInfo)
        
        if (res.code === 200 || res.code === 0) {
          // 更新本地用户信息
          this.userInfo = { ...this.userInfo, ...userInfo }
          this.nickname = userInfo.nickname || this.nickname
          this.avatar = userInfo.avatar || this.avatar
          // 持久化存储更新后的用户信息
          localStorage.setItem('userInfo', JSON.stringify(this.userInfo))
          return true
        }
        return false
      } catch (error) {
        console.error('更新用户信息失败:', error)
        return false
      }
    },
    
    // 修改密码
    async changePassword(passwordData) {
      try {
        const res = await updatePassword(passwordData)
        return res.code === 200 || res.code === 0
      } catch (error) {
        console.error('修改密码失败:', error)
        return false
      }
    },
    
    // 检查Token是否已过期
    isTokenExpired() {
      const tokenData = JSON.parse(localStorage.getItem('tokenData') || '{"timestamp":0}')
      return !tokenData.timestamp || (Date.now() - tokenData.timestamp > TOKEN_EXPIRY)
    }
  }
})